import axios from 'axios'
import { ElMessage } from 'element-plus'
import router from '@/router'
import { getApiBaseUrl } from '@/utils/config'

// API配置
const API_CONFIG = {
  baseURL: getApiBaseUrl(),
  timeout: 15000,
  retryTimes: 2,
  retryDelay: 1000
}

// 请求计数器
let pendingRequests = 0

// 创建axios实例
const api = axios.create({
  baseURL: API_CONFIG.baseURL,
  timeout: API_CONFIG.timeout,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 日期格式化选项
const DATE_TIME_FORMAT = {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit',
  hour: '2-digit',
  minute: '2-digit',
  second: '2-digit'
}

const DATE_FORMAT = {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit'
}

// 添加加载指示器
const showLoading = () => {
  pendingRequests++
  // 如果需要全局加载指示器，可以在这里添加
}

const hideLoading = () => {
  pendingRequests--
  if (pendingRequests <= 0) {
    pendingRequests = 0
    // 如果需要隐藏全局加载指示器，可以在这里添加
  }
}

// 请求拦截器
api.interceptors.request.use(
  config => {
    showLoading()
    
    const token = localStorage.getItem('token')
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`
    }
    
    // 添加请求重试配置
    config.retryTimes = config.retryTimes || API_CONFIG.retryTimes
    config.retryCount = 0
    config.retryDelay = config.retryDelay || API_CONFIG.retryDelay
    
    return config
  },
  error => {
    hideLoading()
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    hideLoading()
    
    // 如果是blob类型的响应，直接返回响应数据
    if (response.config.responseType === 'blob') {
      return response.data
    }
    
    // 打印API响应用于调试
    console.debug(`API Response [${response.config.method.toUpperCase()}] ${response.config.url}:`, response.data)
    
    // 普通JSON响应
    return response.data
  },
  async error => {
    hideLoading()
    let message = '未知错误'
    
    // 打印详细错误用于调试
    console.error('API Error:', error)
    
    // 如果可以重试请求
    const config = error.config
    if (config && config.retryCount < config.retryTimes && (error.code === 'ECONNABORTED' || !error.response)) {
      config.retryCount++
      
      // 延迟一段时间再重试
      await new Promise(resolve => setTimeout(resolve, config.retryDelay))
      
      console.log(`重试请求 (${config.retryCount}/${config.retryTimes}): ${config.url}`)
      return api(config)
    }
    
    if (error.response) {
      const { status, data } = error.response
      
      if (status === 401) {
        // 未授权，清除token并跳转到登录页
        localStorage.removeItem('token')
        localStorage.removeItem('username')
        
        // 避免重复跳转登录页
        if (router.currentRoute.value.name !== 'Login') {
          router.push({ 
            name: 'Login', 
            query: { 
              redirect: router.currentRoute.value.fullPath,
              expired: 'true'
            } 
          })
        }
        message = '登录已过期，请重新登录'
      } else if (status === 403) {
        message = '没有权限执行此操作'
      } else if (status === 404) {
        message = '请求的资源不存在'
      } else if (status === 429) {
        message = '请求过于频繁，请稍后再试'
      } else if (status >= 500) {
        message = '服务器错误，请稍后再试'
      } else if (data && data.detail) {
        // 使用服务器返回的错误信息
        message = data.detail
      } else {
        // 使用HTTP状态文本
        message = `请求错误 (${status})`
      }
    } else if (error.code === 'ECONNABORTED') {
      message = '请求超时，请检查网络连接'
    } else if (error.request) {
      // 请求发送但未收到响应
      message = '服务器无响应，请检查网络连接'
    } else {
      // 请求设置出错
      message = error.message
    }
    
    ElMessage.error(message)
    return Promise.reject(error)
  }
)

// 格式化日期时间
function formatDateTime(dateStr, options = DATE_TIME_FORMAT) {
  if (!dateStr) return ''
  try {
    const date = new Date(dateStr)
    if (isNaN(date.getTime())) return ''
    // 确保使用24小时制
    const formattingOptions = { 
      ...options,
      hour12: false 
    }
    return date.toLocaleString('zh-CN', formattingOptions).replace(/\//g, '-')
  } catch (error) {
    console.error('日期格式化错误:', error)
    return dateStr
  }
}

// 格式化日期
function formatDate(dateStr) {
  return formatDateTime(dateStr, DATE_FORMAT)
}

// 计算任务持续时间（分钟）
function calculateDuration(startTime, endTime) {
  if (!startTime || !endTime) return 0
  try {
    const start = new Date(startTime)
    const end = new Date(endTime)
    if (isNaN(start.getTime()) || isNaN(end.getTime())) return 0
    
    // 计算分钟差
    const diffMs = end.getTime() - start.getTime()
    return Math.round(diffMs / 60000)
  } catch (error) {
    console.error('计算持续时间错误:', error)
    return 0
  }
}

// 导出api实例供其他模块直接使用
export { api as request }

export default {
  // 用户登录
  login(username, password) {
    return api.post('/login', { username, password })
  },

  // 用户注册
  register(username, password) {
    return api.post('/register', { username, password })
  },

  // 获取RPA任务列表
  getRpaJobs(params = {}) {
    // 确保参数有效且格式化正确
    const validParams = { ...params }
    
    // 确保limit和offset是数字类型
    if (validParams.limit) validParams.limit = Number(validParams.limit)
    if (validParams.offset) validParams.offset = Number(validParams.offset)
    
    console.log('Calling API getRpaJobs with params:', validParams);
    return api.get('/v1/rpa_job/', { params: validParams })
  },

  // // 获取仪表盘数据
  // getDashboardData() {
  //   return api.get('/data')
  // },

  // // 获取任务摘要数据
  // getSummaryData() {
  //   return api.get('/summary')
  // },

  // 获取任务详情
  getRpaJobDetail(jobId) {
    return api.get(`/v1/rpa_job/${jobId}`)
  },

  // 删除RPA任务
  deleteRpaJob(jobId) {
    return api.delete(`/v1/rpa_job/${jobId}`)
  },
  
  // 取消运行中的任务
  cancelRpaJob(jobId) {
    return api.post(`/v1/rpa_job/${jobId}/cancel`)
  },
  
  // 获取用户信息
  getUserInfo() {
    return api.get('/v1/user/me')
  },
  
  // 获取用户权限
  getUserPermissions() {
    return api.get('/v1/user/permissions')
  },

  // 格式化工具方法
  formatDateTime,
  formatDate,
  calculateDuration,
  
  // 检测API服务状态
  checkApiHealth() {
    return api.get('/health')
  }
} 